﻿#define _CRT_SECURE_NO_WARNINGS 1
///**给你一个数组 candies 和一个整数 extraCandies ，其中 candies[i] 代表第 i 个孩子拥有的糖果数目。
//
//对每一个孩子，检查是否存在一种方案，将额外的 extraCandies 个糖果分配给孩子们之后，此孩子有 最多 的糖果。注意，允许有多个孩子同时拥有 最多 的糖果数目。
//
//来源：力扣（LeetCode）
//链接：https://leetcode-cn.com/problems/kids-with-the-greatest-number-of-candies
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//* Note: The returned array must be malloced, assume caller calls free().
//*/
//bool* kidsWithCandies(int* candies, int candiesSize, int extraCandies, int* returnSize){
//	*returnSize = candiesSize;
//	char *p = (char*)malloc(candiesSize*sizeof(char));
//	int i = 0;
//	int max = candies[0];
//	for (i = 0; i<candiesSize; i++)
//	{
//		if (candies[i]>max)
//		{
//			max = candies[i];
//		}
//	}
//	for (i = 0; i<candiesSize; i++)
//	{
//		if ((candies[i] + extraCandies) >= max)
//		{
//			p[i] = true;
//		}
//		else
//		{
//			p[i] = false;
//		}
//	}
//	return p;
//}








//给你两个整数，n 和 start 。
//
//数组 nums 定义为：nums[i] = start + 2 * i（下标从 0 开始）且 n == nums.length 。
//
//请返回 nums 中所有元素按位异或（XOR）后得到的结果。
//
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/xor-operation-in-an-array
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int xorOperation(int n, int start){
//	int count = 0;
//	for (int i = 0; i<n; i++)
//	{
//		count ^= (start + i * 2);
//	}
//	return count;
//}







//给你一个整数数组 nums 。
//如果一组数字(i, j) 满足 nums[i] == nums[j] 且 i < j ，就可以认为这是一组 好数对 。
//返回好数对的数目
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/number-of-good-pairs
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int numIdenticalPairs(int* nums, int numsSize){
//	int i = 0;
//	int j = 0;
//	int count = 0;
//	for (i = 0; i<numsSize; i++)
//	{
//		for (j = i + 1; j<numsSize; j++)
//		{
//			if (nums[i] == nums[j])
//			{
//				count++;
//			}
//		}
//	}
//	return count;
//}







//给你一个 m x n 的整数网格 accounts ，其中 accounts[i][j] 是第 i​​​​​​​​​​​​ 位客户在第 j 家银行托管的资产数量。返回最富有客户所拥有的 资产总量 。
//客户的 资产总量 就是他们在各家银行托管的资产数量之和。最富有客户就是 资产总量 最大的客户。
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/richest-customer-wealth
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int maximumWealth(int** accounts, int accountsSize, int* accountsColSize){
//	int max = 0;
//	int i = 0;
//	int j = 0;
//	int count = 0;
//	for (i = 0; i<accountsSize; i++)
//	{
//		count = 0;
//		for (j = 0; j<accountsColSize[i]; j++)
//		{
//			count += accounts[i][j];
//		}
//		max = max>count ? max : count;
//	}
//	return max;
//}









//小A 和 小B 在玩猜数字。小B 每次从 1, 2, 3 中随机选择一个，
//小A 每次也从 1, 2, 3 中选择一个猜。他们一共进行三次这个游戏，请返回 小A 猜对了几次？
//输入的guess数组为 小A 每次的猜测，
//answer数组为 小B 每次的选择。guess和answer的长度都等于3。
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/guess-numbers
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int game(int* guess, int guessSize, int* answer, int answerSize){
//	int i = 0;
//	int count = 0;
//	for (i = 0; i<3; i++)
//	{
//		if (guess[i] == answer[i])
//		{
//			count++;
//		}
//	}
//	return count;
//}







//一个数组的 异或总和 定义为数组中所有元素按位 XOR 的结果；如果数组为 空 ，则异或总和为 0 。
//例如，数组 [2, 5, 6] 的 异或总和 为 2 XOR 5 XOR 6 = 1 。
//给你一个数组 nums ，请你求出 nums 中每个 子集 的 异或总和 ，计算并返回这些值相加之 和 。
//注意：在本题中，元素 相同 的不同子集应 多次 计数。
//数组 a 是数组 b 的一个 子集 的前提条件是：从 b 删除几个（也可能不删除）元素能够得到 a 。
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/sum-of-all-subset-xor-totals
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int subsetXORSum(int* nums, int numsSize){
//	int ret = 0;
//	int i = 0;
//	for (i = 0; i<numsSize; i++)
//	{
//		ret |= nums[i];
//	}
//	return ret << (numsSize - 1);
//}







//给定字符串J 代表石头中宝石的类型，和字符串 S代表你拥有的石头。 S 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。
//
//J 中的字母不重复，J 和 S中的所有字符都是字母。字母区分大小写，因此"a"和"A"是不同类型的石头。
//
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/jewels-and-stones
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int numJewelsInStones(char * jewels, char * stones){
//	int len1 = strlen(jewels);
//	int len2 = strlen(stones);
//	int i = 0;
//	int j = 0;
//	int count = 0;
//	for (i = 0; i<len1; i++)
//	{
//		for (j = 0; j<len2; j++)
//		{
//			if (jewels[i] == stones[j])
//			{
//				count++;
//			}
//		}
//	}
//	return count;
//}










///**给你一个数组 nums 。数组「动态和」的计算公式为：runningSum[i] = sum(nums[0]…nums[i]) 。
//
//请返回 nums 的动态和。
//
//来源：力扣（LeetCode）
//链接：https://leetcode-cn.com/problems/running-sum-of-1d-array
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//* Note: The returned array must be malloced, assume caller calls free().
//*/
//int* runningSum(int* nums, int numsSize, int* returnSize){
//	int i = 0;
//	int* ret = (int*)malloc(numsSize*sizeof(int));
//	*returnSize = numsSize;
//	ret[0] = nums[0];
//	for (i = 1; i<numsSize; i++)
//	{
//		ret[i] = nums[i] + ret[i - 1];
//	}
//	return  ret;
//}







//字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。
//请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，
//该函数将返回左旋转两位得到的结果"cdefgab"。
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/zuo-xuan-zhuan-zi-fu-chuan-lcof
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//char* reverseLeftWords(char* s, int n){
//	char tmp = 0;
//	int len = strlen(s);
//	int i = 0;
//	int j = 0;
//	while (n)
//	{
//		tmp = s[0];
//		for (i = 0; i<len; i++)
//		{
//			s[i] = s[i + 1];
//		}
//		s[len - 1] = tmp;
//		n--;
//	}
//	return s;
//}








//给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。
//你可以假设种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
//你可以按任意顺序返回答案。
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/two-sum
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
///**
//* Note: The returned array must be malloced, assume caller calls free().
//*/
//int* twoSum(int* nums, int numsSize, int target, int* returnSize){
//	int i = 0;
//	int j = 0;
//	int* ret = NULL;
//	*returnSize = 2;
//	for (i = 0; i<numsSize - 1; i++)
//	{
//		for (j = i + 1; j<numsSize; j++)
//		{
//			if (nums[i] + nums[j] == target)
//			{
//				ret = (int*)malloc(sizeof(int) * 2);
//				ret[0] = i;
//				ret[1] = j;
//				return ret;
//			}
//		}
//	}
//	return ret;
//}